Contents
- 1 Simple Way
- 2 Add Elemental Component To It
- 3 Add crypto data
- 4 Simple Training
- 5 Moving to more data (Bitstamp)
- 6 Regenerate Dataset with alternative labeling: -1, 0, 1, 2
- 7 Time to add dummy data to the rotators
- 8 Let's re-arrange the order of the planets
- 9 Adding Time-Split Into Cyclical Variables
- 10 Converting Planet Angles to One-Hot Encodings
- 11 Next steps
- 12 Old School Way
In [1]:
%load_ext autoreload
%autoreload 2
In [2]:
from skyfield.api import load
import numpy as np
import math
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from skyfield.api import utc
from scipy.optimize import brentq # machine learning
from datetime import timedelta, datetime
import pytz
In [3]:
from definitions import *
In [300]:
from_binary_to_element_symbols = {
'11': '🜁',
'01': '🜂',
'10': '🜄',
'00': '🜃',
}
# from_binary_to_element_ix = {
# '11': '0',
# '01': '1',
# '10': '2',
# '00': '3',
# }
from_binary_to_element_ix = {
'11': '-1',
'01': '0',
'10': '1',
'00': '2',
}
In [301]:
b_to_q = lambda x: [from_binary_to_element_symbols[x[i*2:i*2+2]] for i in [0,1,2]]
b_to_q_el = lambda x: [from_binary_to_element_ix[x[i*2:i*2+2]] for i in [0,1,2]]
In [302]:
from_binary_to_element_symbols['00']
Out[302]:
In [303]:
print ( b_to_q('000000'))
print ( b_to_q_el('101010'))
In [304]:
# index elemental composition of the I Ching
iching_ix = [b_to_q_el(str(x['binary']))for x in iching]
In [305]:
# binary position of the I Ching
iching_binary = [b_to_q(str(x['binary']))for x in iching]
In [306]:
# important parameters
design_offset = 88 * math.pi / 180 # required to determine design parameters
earth_offset = math.pi # earth offset (180* against the sun)
pi2 = math.pi*2 # circle constant
# Important parameters and statistics for mandala wheel calculation
hex_width = pi2/64
line_width = hex_width/6
color_width = line_width/6
tone_width = color_width/6
base_width = tone_width/5
In [307]:
# Credits to Ra Uru Hu for receiving this info
iching_map = [36, 22, 63, 37, 55, 30, 49, 13, 19, 41, 60, 61, 54, 38, 58, 10, 11, 26, 5, 9, 34, 14, 43, 1, 44, 28, 50, 32, 57, 48, 18, 46, 6, 47, 64, 40, 59, 29, 4, 7, 33, 31, 56, 62, 53, 39, 52, 15, 12, 45, 35, 16, 20, 8, 23, 2, 24, 27, 3, 42, 51, 21, 17, 25]
iching_map.reverse()
In [308]:
# how precise decimals are shown in table
pd.set_option('display.float_format', '{:.10f}'.format)
In [309]:
# load Ephemeris
# load library planet position file
planets = load('de431t.bsp')
_planets = {
"sun": planets['SUN'],
"earth": planets['EARTH'],
"moon": planets['MOON'],
"mercury": planets['MERCURY'],
"venus": planets['VENUS BARYCENTER'],
"mars": planets['MARS BARYCENTER'],
"jupiter": planets['JUPITER BARYCENTER'],
"saturn": planets['SATURN BARYCENTER'],
"uranus": planets['URANUS BARYCENTER'],
"neptune": planets['NEPTUNE BARYCENTER'],
"pluto": planets['PLUTO BARYCENTER'],
}
In [310]:
ts = load.timescale(builtin=True)
Simple Way¶
In [311]:
# For iInfo Purposes
# lat = _planets['earth'].at(t_time_array).observe(_planets['venus']).ecliptic_latlon()[0].radians - *math.pi
# lon = _planets['earth'].at(t_time_array).observe(_planets['venus']).ecliptic_latlon()[1].radians - math.pi
# d = _planets['earth'].at(t_time_array).observe(_planets['venus']).ecliptic_latlon()[2]
In [312]:
def generate_planets(time_range):
""" Generates a dataframe for the registered collection of dates """
df = pd.DataFrame()
df['time'] = np.array(time_range.tt)
for planet_name, p in _planets.items():
earth_offset = math.pi if planet_name == "earth" else 0.0
df[planet_name] = _planets['earth'].at(time_range).observe(p).ecliptic_latlon()[1].radians + earth_offset # latitude
return df
In [313]:
hours_in_100_years = 24 * 365 * 10
t_time_array = ts.utc(2010, 1, 1, range(0,hours_in_100_years), 0) # -3000 BC to 3000 BC, increments in hours
df_planets = generate_planets(t_time_array) # takes a while
In [314]:
t_time_array[0]
Out[314]:
In [315]:
df_planets.tail()
Out[315]:
In [316]:
len(df_planets)
Out[316]:
Add Elemental Component To It¶
In [317]:
import math
In [318]:
math.pi
Out[318]:
In [23]:
# for one rad, return array of elements
# for one row, return array of elements
# for one
In [24]:
df_planets.apply(lambda x: x/(math.pi**2))
Out[24]:
In [25]:
import seaborn as sns
In [26]:
normalize_squared = lambda x: x/(math.pi**2)
normalize = lambda x: x/(math.pi)
# df_planets.apply(lambda x: x/(math.pi**2))
In [27]:
df_planets['earth'] = df_planets['sun'] - math.pi
In [28]:
sns.lineplot(x='time', y='earth', data=df_planets[:2000])
Out[28]:
In [29]:
sns.lineplot(x='time', y='sun', data=df_planets.apply(normalize)[:2000])
Out[29]:
In [30]:
sns.lineplot(x='time', y='sun', data=df_planets.apply(normalize_squared)[:2000])
Out[30]:
Define several functions¶
In [31]:
def neutron_stream_pos(planet_position):
""" returns mandala position (base 64) given planet position"""
return ( (planet_position + (2*line_width - 1*color_width - 2*tone_width) ) / (2*math.pi) * 64) % 64
In [32]:
def map_on_hexagram(df):
""" maps df planet positions onto position onto a hexagram and line """
# convert dataframe to numpy array
neutron_stream = df.to_numpy()
hexagram_bin = np.floor(neutron_stream) # rounded up downwards
# map bin number onto 'hexagram' (neutron stream is sequential order, hexagram is King Wen Sequence)
strong = np.array(iching_map)
flat = hexagram_bin.astype(int).flatten()
previous_shape = neutron_stream.shape
mapped = strong[flat]
hexagram = mapped.reshape(previous_shape)
hexagram_fraction = neutron_stream - hexagram_bin
line = hexagram_fraction // (1/6) + 1 # count in which 6th this neutrino stream falls in
line_fraction = (hexagram_fraction - (line - 1)*1/6 ) / (1/6)
color = line_fraction // (1/6) + 1
color_fraction = (line_fraction - (color -1) * 1/6) / (1/6)
tone = color_fraction // (1/6) + 1
return hexagram #, line.astype(int), color.astype(int), tone.astype(int)
In [33]:
# map 'neutron' stream, aka influences of the probability field (the planets in the solar system physical space)
df_angles = neutron_stream_pos(df_planets.iloc[:, 1:6])
z = map_on_hexagram(df_angles)
z
Out[33]:
In [34]:
many_2_b = np.array(iching_binary) # strong
many_2 = np.array(iching_ix) # strong
one_2 = z.astype(int).flatten() - 1 # flat
In [35]:
many_2_b[63]
Out[35]:
In [36]:
# binary el
el_b = many_2_b[one_2]
# normal el (0 -> 3)
el = many_2[one_2]
el_b
Out[36]:
In [37]:
el.shape
Out[37]:
In [38]:
z.shape
Out[38]:
In [39]:
el.reshape((87600, 5, 3))
Out[39]:
In [40]:
finish = el.reshape((87600, 15))
finish
Out[40]:
In [41]:
df_finish = pd.DataFrame(finish)
df_finish.head(20)
Out[41]:
In [42]:
import seaborn as sns
In [43]:
uniform_data = np.random.rand(10, 12)
In [44]:
data = finish.astype(int)
In [45]:
data[1:5].shape
Out[45]:
In [46]:
ax = sns.heatmap(data[1:10])
In [47]:
ax = sns.heatmap(data[1:50])
In [48]:
ax = sns.heatmap(data[1:100])
In [49]:
ax = sns.heatmap(data[1:500])
In [50]:
ax = sns.heatmap(data[1:3000])
let's add extra time to see how this progresses
In [51]:
ax = sns.heatmap(data[3000:6000])
In [52]:
ax = sns.heatmap(data[6000:9000])
In [53]:
ax = sns.heatmap(data[9000:12000])
In [54]:
ax = sns.heatmap(data[12000:15000])
In [55]:
ax = sns.heatmap(data[0:10000])
In [56]:
ax = sns.heatmap(data[0:80000])
In [ ]:
In [57]:
water = sns.color_palette("tab10")[0]
air = sns.color_palette("tab10")[1]
earth = sns.color_palette("tab10")[2]
fire = sns.color_palette("tab10")[3]
color_map = [air, fire, water, earth]
In [58]:
fig, ax = plt.subplots(figsize=(10,50))
sns.heatmap(data[0:10000], ax=ax, cmap=color_map, cbar=False)
Out[58]:
In [59]:
data.transpose()
Out[59]:
In [ ]:
In [60]:
one_year = 24 * 365
In [61]:
fig, ax = plt.subplots(figsize=(50,5))
sns.heatmap(data[one_year*0:one_year*1].transpose(), ax=ax, cmap=color_map, cbar=False)
Out[61]:
In [62]:
fig, ax = plt.subplots(figsize=(50,5))
sns.heatmap(data[one_year*1:one_year*2].transpose(), ax=ax, cmap=color_map, cbar=False)
Out[62]:
In [63]:
fig, ax = plt.subplots(figsize=(50,5))
sns.heatmap(data[one_year*2:one_year*3].transpose(), ax=ax, cmap=color_map, cbar=False)
Out[63]:
In [64]:
fig, ax = plt.subplots(figsize=(50,5))
sns.heatmap(data[one_year*3:one_year*4].transpose(), ax=ax, cmap=color_map, cbar=False)
Out[64]:
In [ ]:
More Experiments¶
There's something wrong with the currently presented mapping, as it doesn't show fire-fire-fire (63) nor water-water-water (64). This causes a lot of randomness which can be best dealt with from the start, before any further iteration occurs.
In [71]:
data_fixed = finish.astype(int)
In [72]:
water = "#0E61B0"
air = "#C29F17"
earth = "#55A349"
fire = "#C9280C"
color_map = [air, fire, water, earth]
In [73]:
fig, ax = plt.subplots(figsize=(50,5))
sns.heatmap(data_fixed[one_year*0:one_year*1].transpose(), ax=ax, cmap=color_map, cbar=False)
Out[73]:
In [74]:
## add a few planets
In [75]:
data_tmp = get_elemental_map(df_planets.loc[:,['earth','moon','mercury','venus','sun', 'mars', 'jupiter','saturn', 'uranus','neptune']])
fig, ax = plt.subplots(figsize=(50,10))
sns.heatmap(data_tmp[one_year*0:one_year*1].transpose(), ax=ax, cmap=color_map, cbar=False)
Out[75]:
2019-2021¶
In [79]:
hours_in_desired_timespan = 24 * 365 * 2 # 2 years in hours
t_time_array = ts.utc(2019, 1, 1, range(0,hours_in_desired_timespan), 0) # -3000 BC to 3000 BC, increments in hours
df_planets_2019_2020 = generate_planets(t_time_array) # takes a while
In [80]:
r = ['earth','moon','mercury','venus','sun', 'mars', 'jupiter','saturn', 'uranus','neptune']
r.reverse()
In [81]:
data_tmp = get_elemental_map(df_planets_2019_2020.loc[:,r])
fig, ax = plt.subplots(figsize=(50,15))
sns.heatmap(data_tmp.transpose(), ax=ax, cmap=color_map, cbar=False)
Out[81]:
In [83]:
print (t_time_array[0].utc_datetime())
print (t_time_array[hours_in_desired_timespan-1].utc_datetime())
In [ ]:
In [ ]:
Add crypto data¶
In [84]:
import pandas as pd
import numpy as np
In [85]:
df_c = pd.read_csv('Binance_BTCUSDT_1h.csv', parse_dates=True)
In [86]:
df_c['date'].dtype
Out[86]:
In [87]:
df_c['date'] = pd.to_datetime(df_c['unix'], unit='ms')
In [88]:
df_money = df_c.set_index('date')
In [89]:
df_money['close'].plot()
Out[89]:
In [90]:
len(df_money)
Out[90]:
In [92]:
df_money
Out[92]:
In [98]:
hours_in_trading_code = len(df_money) # stock exchange count of number differences
t_time_array = ts.utc(2020, 8, 1, range(0,hours_in_trading_code), 0) # -3000 BC to 3000 BC, increments in hours
df_crypto_2_months = generate_planets(t_time_array) # takes a while
In [101]:
r = ['earth','moon','mercury','venus','sun', 'mars', 'jupiter','saturn', 'uranus','neptune']
r.reverse()
data_tmp = get_elemental_map(df_crypto_2_months.loc[:,r])
fig, ax = plt.subplots(figsize=(15,15))
sns.heatmap(data_tmp.transpose(), ax=ax, cmap=color_map, cbar=False)
Out[101]:
In [103]:
fig, ax = plt.subplots(figsize=(15,15))
df_money['close'].plot()
Out[103]:
In [124]:
df_solar = pd.DataFrame(data_tmp)
df_solar.index = df_money.index
#df_money.loc[['close']].join(df_solar)
df_dataset = pd.concat([df_money[['close']], df_solar], axis=1)
In [125]:
df_dataset.head()
Out[125]:
Simple Training¶
In [ ]:
from sklearn import svm
In [129]:
len(df_dataset)
Out[129]:
In [ ]:
train_size = 0.8
In [ ]:
In [145]:
df_x = df_dataset[df_dataset.columns[1:]]
df_y = df_dataset['close']
In [157]:
train_x = df_x[:3000]
train_y = df_y[:3000]
test_x = df_x[3000:]
test_y = df_y[3000:]
In [158]:
from sklearn import svm
In [167]:
X = train_x.to_numpy()
y = train_y.to_numpy()
regr = svm.SVR(kernel='poly', C=100, gamma=0.1, epsilon=.1)
regr.fit(X, y)
Out[167]:
In [178]:
results = pd.DataFrame()
results['test_x'] = regr.predict(test_x)
results['test_y'] = list(test_y)
results.plot()
In [179]:
results.plot()
Out[179]:
In [181]:
results = pd.DataFrame()
results['test_x'] = regr.predict(train_x)
results['test_y'] = list(train_y)
results.plot()
Out[181]:
Moving to more data (Bitstamp)¶
In [328]:
df_hourly.iloc[0].name.year
Out[328]:
In [347]:
df_solar.index
Out[347]:
In [354]:
def get_crypto_planet_data(size):
df_c = pd.read_csv('bitstampUSD_1-min_data_2012-01-01_to_2020-09-14.csv', parse_dates=True)
# make data timestamp
df_c['date'] = pd.to_datetime(df_c['Timestamp'], unit='s')
# cast down to hourly data
groupkey = pd.to_datetime(df_c[-size:].date.dt.strftime('%Y-%m-%d %H'))
df_hourly = df_c[-size:].groupby(groupkey).agg({'Close':'last','Volume_(BTC)':'sum'})
df_hourly.head()
first_date = df_hourly.iloc[0].name
print ( first_date )
# generate ephemerial elements
h = first_date.hour
hours_in_trading_code = len(df_hourly) # stock exchange count of number differences
t_time_array = ts.utc(first_date.year, first_date.month, first_date.day, range(h,h+hours_in_trading_code), 0) # -3000 BC to 3000 BC, increments in hours
# generate empheremis for time period
df_crypto_planets = generate_planets(t_time_array) # can take a while
# selected desired planets for attribution
r = ['earth','moon','mercury','venus','sun', 'mars', 'jupiter','saturn', 'uranus','neptune']
r.reverse()
# create elemental data map
data_tmp = get_elemental_map(df_crypto_planets.loc[:,r])
# plot data map
fig, ax = plt.subplots(figsize=(5,5))
sns.heatmap(data_tmp.transpose(), ax=ax, cmap=color_map, cbar=False)
# create the training dataset [Close, Solar System Time]
df_solar = pd.DataFrame(data_tmp)
df_solar.index = df_hourly.index
#df_money.loc[['close']].join(df_solar)
df_dataset = pd.concat([df_hourly[['Close']], df_solar], axis=1)
return df_dataset
In [355]:
get_data = get_crypto_planet_data(1000000)
len(get_data)
Out[355]:
In [231]:
df_c = pd.read_csv('bitstampUSD_1-min_data_2012-01-01_to_2020-09-14.csv', parse_dates=True)
In [187]:
# make data timestamp
df_c['date'] = pd.to_datetime(df_c['Timestamp'], unit='s')
In [209]:
len(df_c[-50000:])
Out[209]:
In [218]:
# cast down to hourly data
groupkey = pd.to_datetime(df_c[-500000:].date.dt.strftime('%Y-%m-%d %H'))
df_hourly = df_c[-500000:].groupby(groupkey).agg({'Close':'last','Volume_(BTC)':'sum'})
df_hourly.head()
Out[218]:
In [219]:
len(df_hourly)
Out[219]:
In [222]:
df_hourly.plot()
Out[222]:
In [225]:
df_hourly.iloc[0]
Out[225]:
In [226]:
# generate ephemerial elements
hours_in_trading_code = len(df_hourly) # stock exchange count of number differences
t_time_array = ts.utc(2019, 10, 2, range(0,hours_in_trading_code), 0) # -3000 BC to 3000 BC, increments in hours
df_crypto_2_months = generate_planets(t_time_array) # takes a while
r = ['earth','moon','mercury','venus','sun', 'mars', 'jupiter','saturn', 'uranus','neptune']
r.reverse()
data_tmp = get_elemental_map(df_crypto_2_months.loc[:,r])
fig, ax = plt.subplots(figsize=(5,5))
sns.heatmap(data_tmp.transpose(), ax=ax, cmap=color_map, cbar=False)
Out[226]:
In [228]:
# create the training dataset
df_solar = pd.DataFrame(data_tmp)
df_solar.index = df_hourly.index
#df_money.loc[['close']].join(df_solar)
df_dataset = pd.concat([df_hourly[['Close']], df_solar], axis=1)
df_dataset.head()
Out[228]:
In [ ]:
df_dataset
In [235]:
df_dataset.Close.dtype
Out[235]:
In [ ]:
In [ ]:
In [ ]:
from sklearn import svm
In [275]:
# prepaire dataset for training
df_x = df_dataset[df_dataset.columns[1:]]
df_x = df_x[df_dataset['Close'].isnull() != True]
df_y = df_dataset['Close'].dropna()
# we train on this
train_x = df_x[:6000]
train_y = df_y[:6000]
# we test on this (validate)
test_x = df_x[6000:]
test_y = df_y[6000:]
In [276]:
test_x.shape
Out[276]:
In [277]:
df_y[df_y.isnull() == True]
Out[277]:
In [282]:
X = train_x.to_numpy()
y = train_y.to_numpy()
regr = svm.SVR(kernel='linear', C=100, gamma=0.1, epsilon=.1)
regr.fit(X, y)
Out[282]:
In [280]:
results = pd.DataFrame()
results['test_x'] = regr.predict(test_x)
results['test_y'] = list(test_y)
results.plot()
Out[280]:
In [281]:
# adjust for start
In [291]:
# train the model
X = train_x.to_numpy()
y = train_y.to_numpy()
regr = svm.SVR(kernel='rbf', C=100, gamma=0.001, epsilon=.1)
regr.fit(X, y)
Out[291]:
In [292]:
# see results
results = pd.DataFrame()
results['test_x'] = regr.predict(test_x)
results['test_y'] = list(test_y)
results.plot()
Out[292]:
In [293]:
# train the model
X = train_x.to_numpy()
y = train_y.to_numpy()
regr = svm.SVR(kernel='rbf', C=1000, gamma=0.001, epsilon=.1)
regr.fit(X, y)
# see results
results = pd.DataFrame()
results[''] = regr.predict(test_x)
results['test_y'] = list(test_y)
results.plot()
Out[293]:
In [298]:
start_offset = results['test_y'][0] - results['test_x'][0]
results['test_x'] += start_offset
In [299]:
results.plot()
Out[299]:
Regenerate Dataset with alternative labeling: -1, 0, 1, 2¶
In [356]:
get_data = get_crypto_planet_data(1000000)
len(get_data)
Out[356]:
In [357]:
# prepaire dataset for training
df_x = get_data[get_data.columns[1:]]
df_x = df_x[get_data['Close'].isnull() != True]
df_y = get_data['Close'].dropna()
# we train on this
train_x = df_x[:10000].to_numpy()
train_y = df_y[:10000].to_numpy()
# we test on this (validate)
test_x = df_x[10000:]
test_y = df_y[10000:]
In [358]:
# train model
regr = svm.SVR(kernel='linear', C=100, gamma=0.1, epsilon=.1)
regr.fit(train_x, train_y)
Out[358]:
In [359]:
# see results
results = pd.DataFrame()
results['test_x'] = regr.predict(test_x)
results['test_y'] = list(test_y)
results.plot()
Out[359]:
In [361]:
# train the model
regr = svm.SVR(kernel='rbf', C=100, gamma=0.001, epsilon=.1)
regr.fit(train_x, train_y)
# see results
results = pd.DataFrame()
results['test_x'] = regr.predict(test_x)
results['test_y'] = list(test_y)
results.plot()
Out[361]:
In [366]:
results = pd.DataFrame()
results['test_x'] = np.diff(regr.predict(test_x))
results['test_y'] = np.diff(list(test_y))
results.plot()
Out[366]:
In [367]:
# train the model
regr = svm.SVR(kernel='rbf', C=1000, gamma=0.001, epsilon=.01)
regr.fit(train_x, train_y)
# see results
results = pd.DataFrame()
results['test_x'] = regr.predict(test_x)
results['test_y'] = list(test_y)
results.plot()
Out[367]:
In [372]:
# train the model
regr = svm.SVR(kernel='poly', C=100, gamma=0.01, epsilon=.1)
regr.fit(train_x, train_y)
# see results
results = pd.DataFrame()
results['test_x'] = regr.predict(test_x)
results['test_y'] = list(test_y)
results.plot()
Out[372]:
In [375]:
# train the model
regr = svm.SVR(kernel='sigmoid', C=100, gamma=0.001, epsilon=.0001)
regr.fit(train_x, train_y)
# see results
results = pd.DataFrame()
results['test_x'] = regr.predict(test_x)
results['test_y'] = list(test_y)
results.plot()
Out[375]:
In [ ]:
Time to add dummy data to the rotators¶
In [420]:
get_data = get_crypto_planet_data(1000000)
len(get_data)
Out[420]:
In [ ]:
In [421]:
get_data.columns = ['Close']+ [str(x)+'_pl' for x in get_data.iloc[:,1:].columns]
In [422]:
get_data.columns
Out[422]:
In [423]:
get_data.iloc[:,1:] = get_data.iloc[:,1:].astype(str)
In [426]:
get_data_flat = pd.get_dummies(get_data.iloc[:,1:])
In [429]:
get_data_flat['Close'] = get_data.Close
In [430]:
# prepaire dataset for training
df_x = get_data_flat[get_data_flat.columns[1:]]
df_x = df_x[get_data_flat['Close'].isnull() != True]
df_y = get_data_flat['Close'].dropna()
# we train on this
train_x = df_x[:10000].to_numpy()
train_y = df_y[:10000].to_numpy()
# we test on this (validate)
test_x = df_x[10000:]
test_y = df_y[10000:]
In [431]:
# train the model
regr = svm.SVR(kernel='rbf', C=100, gamma=0.001, epsilon=.1)
regr.fit(train_x, train_y)
# see results
results = pd.DataFrame()
results['test_x'] = regr.predict(test_x)
results['test_y'] = list(test_y)
results.plot()
Out[431]:
In [442]:
from sklearn.metrics import explained_variance_score, mean_squared_error, r2_score
In [443]:
print ("Explained Variance:",explained_variance_score(results['test_y'].to_numpy(), results['test_x'].to_numpy()))
print ("MSE:", mean_squared_error(results['test_y'].to_numpy(), results['test_x'].to_numpy()))
print ("R2",r2_score(results['test_y'].to_numpy(), results['test_x'].to_numpy()))
Are you fucking shitting me that the algorithm almost 1:1 predicted whole 2020, based on 2019 data.
We're literally seeing 0.8866 variance explained... BY PLANET POSITIONS?
In [ ]:
In [ ]:
# train the model
regr = svm.SVR(kernel='poly', C=100, gamma=0.001, epsilon=.01)
regr.fit(train_x, train_y)
# see results
results = pd.DataFrame()
results['test_x'] = regr.predict(test_x)
results['test_y'] = list(test_y)
results.plot()
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
Animate¶
In [58]:
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import matplotlib.animation as ani
import numpy as np
import pandas as pd
from celluloid import Camera
fig = plt.figure()
camera = Camera(fig) # https://pypi.org/project/celluloid/
# ax1 = plt.subplot2grid ((2, 2), (0, 0), colspan=2, rowspan=2)
for i in range(30):
#data = np.random.normal(0, 10, i+1)
#pd.DataFrame(data).plot(kind='bar', ax=ax1)
ax = sns.heatmap(data[i*50:2000+i*50], cbar=False)
# ax._legend().remove()
camera.snap()
# Set up formatting for the movie files
Writer = ani.writers['ffmpeg']
writer = Writer(fps=30, metadata=dict(artist='Me'), bitrate=1800)
# anim = ani.ArtistAnimation(fig, ims, interval=500, repeat_delay=3000, blit=True)
anim = camera.animate(interval=50000, repeat_delay=5000)
anim.save('textmovie.mp4', writer=writer)
Let's re-arrange the order of the planets¶
In [70]:
def get_elemental_map(df_planets):
# map 'neutron' stream, aka influences of the probability field (the planets in the solar system physical space)
# position to index on a wheel
df_planets['earth'] = df_planets['sun'] - math.pi
df_angles = neutron_stream_pos(df_planets)
# index on a wheel to specific binary I-Ching Sequence - King Wen Version
z = map_on_hexagram(df_angles)
many_2_b = np.array(iching_binary) # strong
many_2 = np.array(iching_ix) # strong
one_2 = z.astype(int).flatten() - 1 # flat
# binary el
el_b = many_2_b[one_2]
# normal el (0 -> 3)
el = many_2[one_2]
finish = el.reshape((df_angles.shape[0], df_angles.shape[1]*3))
return finish.astype(int)
In [131]:
temp = get_elemental_map(df_planets.loc[:,['earth','moon','mercury','venus','sun', 'mars', 'jupiter','saturn', 'uranus','neptune']])
temp
Out[131]:
In [132]:
ax = sns.heatmap(temp[1:500])
In [133]:
ax = sns.heatmap(temp[1:3000])
ladies and gentlemen, we're looking at the jaws of a new discovery in our universe¶
In [ ]:
In [ ]:
In [134]:
ax = sns.heatmap(temp[1:30000])
In [70]:
df_planets.columns
Out[70]:
In [ ]:
In [ ]:
In [ ]:
Adding Time-Split Into Cyclical Variables¶
We want to convert the julian-time to a series of values of increment
In [141]:
t = df.time[0]
t
Out[141]:
In [742]:
def test_get_buckets(j_tt, mod_period):
for index, rotor in enumerate(range(-10,9)):
print ( math.floor(j_tt % (mod_period**rotor) / (mod_period**rotor) * mod_period) , '%', (mod_period**rotor))
def value_to_rotor(j_tt, mod_period, n_rotor_range_min=-15, n_rotor_range_max=15):
""" Returns rotary bins. Mod_periods=2 returns binary. mod_period=10 returns decimal arrangement
Good default value for n_rotor_range = 10 (this defines how many rotors there are)
"""
rotor = []
for r in range(n_rotor_range_min, n_rotor_range_max):
rot = math.floor(j_tt % (mod_period**r) / (mod_period**r) * mod_period)
rotor.append(rot)
return rotor
def rotor_to_value(rotor, mod_period, n_rotor_range_min=-15, n_rotor_range_max=15):
""" Converts rotary bins back to a decimal value """
julian_time = 0.0
print (n_rotor_range_min, n_rotor_range_max)
for index, r in enumerate(range(n_rotor_range_min, n_rotor_range_max)):
julian_time += rotor[index] * (mod_period**(r+1)) / (mod_period**2)
return julian_time
def encode_value_to_one_hot_rotor(value, mod_period, n_rotor_range_min=-15, n_rotor_range_max=15):
""" Converts a value to a 1-hot encoded rotor array """
values = value_to_rotor(value, mod_period, n_rotor_range_min, n_rotor_range_max) # get time rotation of j_tt (julian)
n_values = mod_period # = max value of period
return np.eye(n_values)[values].flatten()
def decode_one_hot_rotor_to_value(flat_1hot_rotor, mod_period, n_rotor_range_min=-15, n_rotor_range_max=15):
""" Converts a one hot rotor back to a value """
# convert to the numpy useful one-hot encoding of the different bins (there mod_period amount in every encoding)
onehot = np.reshape(flat_1hot_rotor, (int(len(flat_1hot_rotor)/mod_period),mod_period))
# get rotor values (1hot -> category array)
rotor = np.argmax(onehot, axis=1)
# convert to value
value = rotor_to_value(rotor, mod_period, n_rotor_range_min, n_rotor_range_max)
return value
In [734]:
# small little test for the bucketing system
print (df.time[0])
test_get_buckets(df.time[0], 10) # test
In [735]:
# below snippet is how to create categorical variables
values = [1, 0, 3]
categories = np.eye(4)[values] # 4 categories
categories
Out[735]:
In [736]:
# back to category array
np.argmax(categories, axis=1)
Out[736]:
In [737]:
# further testing
r = value_to_rotor(df.time[0], 4, -15, 15)
print ("Julian time:", df.time[0])
print("to")
print ("Rotor encoded:",r)
In [744]:
_t = rotor_to_value(r, 4, -15, 15)
print("Rotor encoded:",r)
print("to")
print("Julian Time from rotor", _t)
In [ ]:
In [845]:
def test_encode_decode(value, mod_rotor, n_rotor_range_min, n_rotor_range_max):
a_time_rotor = encode_value_to_one_hot_rotor(value, mod_rotor, n_rotor_range_min, n_rotor_range_max)
value_decoded = decode_one_hot_rotor_to_value(a_time_rotor, mod_rotor, n_rotor_range_min, n_rotor_range_max)
print ("Julian time:", value)
print ("Flat One Hot Array:", a_time_rotor, " with length:", len(a_time_rotor))
print ("Decoded Rotor:", value_decoded)
print ("Error:", value_decoded - value)
In [846]:
test_encode_decode(df.time[1000], 4, -15, 15)
We'll be adding all these arrays to a dataframe, then transposing it to get the dummy values.
In [762]:
# this might take a time... It creates a dataframe from a series of values (like a column)
def value_array_to_rotor_df(value_array, prefix="_", mod_rotor = 4, n_rotor_range_min=-15, n_rotor_range_max=15):
encode = np.zeros((len(value_array),mod_rotor*(n_rotor_range_max-n_rotor_range_min)))
# do it across our time_range (currently in use)
time_rotors = []
for ii, t in enumerate(value_array):
encode[ii,:] = np.array(encode_value_to_one_hot_rotor(t, mod_rotor, n_rotor_range_min, n_rotor_range_max))
df_rotor = pd.DataFrame(encode)
df_rotor = df_rotor.add_prefix(prefix)
return df_rotor
In [764]:
df_time_rotor = value_array_to_rotor_df(t_time_array.tt, "time_rot_", 4, -15, 15)
In [765]:
df_time_rotor.head()
Out[765]:
In [766]:
len(df_time_rotor)
Out[766]:
In [767]:
encode.shape
Out[767]:
Now add time_rot_ to df_planets, containing our ephimeris. It essentially displays time as a series of buckets
In [768]:
df_planets_with_trotor = df_planets.merge(df_time_rotor, left_index=True, right_index=True)
df_planets_with_trotor.head()
Out[768]:
We quickly check if the values are correctly encoded:
In [769]:
# Testing of time rotor values
filter_col = [col for col in df_planets_with_trotor if col.startswith('time_rot_')]
print ("Julian Time:",df_planets_with_trotor.loc[5500,'time'])
rot = np.array(df_planets_with_trotor.loc[5500,filter_col])
print ("Rotor:", rot)
In [771]:
decode_one_hot_rotor_to_value(rot, 4, -15, 15)
Out[771]:
Converting Planet Angles to One-Hot Encodings¶
In [773]:
print (df_planets_with_trotor.jupiter.min() * 180.0 / math.pi )
print (df_planets_with_trotor.jupiter.max() * 180.0 / math.pi )
First let's determine optimale rotor_count (range)
In [832]:
print ("Our maximum difference between 2 values is is maximum this value", df_planets_with_trotor.sun.diff().max())
print ("So let's not add useless precision to the onehot encoding")
In [853]:
val = df_planets_with_trotor.sun.max()
test_encode_decode(val, 4, -10, 3) # optimale parameters for 0 error
val = df_planets_with_trotor.sun.min()
test_encode_decode(val, 4, -10, 3) # optimale parameters for 0 error
Above errors are small enough to proceed with this encoding.
Let's proceed with encoding all planets¶
In [839]:
planets = ['moon', 'mercury', 'venus', 'sun', 'mars', 'jupiter', 'saturn', 'uranus', 'neptune', 'pluto']
In [842]:
for planet_name in planets:
print ("Encoding:", planet_name)
# calculate rotor for planet
df_planet_rotor = \
value_array_to_rotor_df(df_planets_with_trotor[planet_name], planet_name+"_rot_", 4, -10, 3)
# add planet to `df_planets_with_trotor`
df_planets_with_trotor = df_planets_with_trotor.merge(df_planet_rotor, left_index=True, right_index=True)
In [849]:
df_planets_with_trotor.drop('earth', axis=1, inplace=True)
df_planets_with_trotor.head()
Out[849]:
In [852]:
df_planets_with_trotor.to_csv("100_year_rotor_encoded_ephemeris.csv", sep=';', index=False)
In [854]:
len (df_planets_with_trotor)
Out[854]:
Next steps¶
- Divide dataset in 1/2 (50 years), one for training, one for testing
- Setup input training data:
- X = Time Rotor input (120)
- Y = 52 (1 observed sphere) -> the moon (use script to get columns starting with "moonrot"
When more planets will be active, the loss algorithm should be taking an argmax across "planet rotors", so that the neural network learns the "sphere grouping" across outputs (520 when taking all spheres into account).
We train till the precision will be small enough, say E <= 0.00001, should be adequate enough I think.
Then we validate the data on the other 50 years, and we're very anxious for the results.
In [ ]:
Old School Way¶
In [13]:
def planet1_looks_at_planet2(p1, p2, t):
return p1.at(t).observe(p2).apparent()
def observe(p1, p2, t):
""" Observe planet 1 to planet 2 ... observe(p1, p2, timestamp).degrees, or use .radians for radiance """
t = get_ts(t)
astrometric = planet1_looks_at_planet2(p1, p2, t)
_, lon, _ = astrometric.ecliptic_latlon()
return lon
def getEarthPos(t, planet):
""" Given a time t and planet p, return longitude position of planet on ecliptic plane """
return observe(_planets['earth'], planet, t).radians
In [14]:
t = datetime(1, 12, 9, 0, 14, 0, tzinfo=utc)
In [15]:
t
Out[15]:
In [5]:
t = datetime(1970, 12, 9, 0, 14, 0, tzinfo=utc)
earth = _planets['earth']
jupiter = _planets['jupiter']
observe(earth, jupiter, t).radians
Out[5]:
Generate a whole set of dates, spaced every 2H¶
In [6]:
start = datetime(1970, 1, 1, 0, 0, 0, tzinfo=utc)
end = datetime(2020, 4, 12, 0, 0, 0, tzinfo=utc)
dates = pd.date_range(start = start, end = end, tz=pytz.UTC, freq='2H').to_pydatetime().tolist()
# reason for 2H frequency: we want to divide the day up in 12 segments, which is a nice amount
len(dates)
Out[6]:
In [75]:
import math
In [102]:
bodies = ['sun', 'earth', 'moon', 'venus', 'mars', 'jupiter']
positions = {
'sun': (lambda t: observe(earth, _planets['sun'], t).radians),
'earth': (lambda t: observe(earth, _planets['sun'], t).radians - math.pi),
'moon': (lambda t: observe(earth, _planets['moon'], t).radians),
'venus': (lambda t: observe(earth, _planets['venus'], t).radians),
'mars': (lambda t: observe(earth, _planets['mars'], t).radians),
'jupiter': (lambda t: observe(earth, _planets['jupiter'], t).radians)
}
def generate_table(dates):
new_table = {}
new_table['t'] = dates
for b in bodies:
new_table[b] = [] # assign body nae as key
for t in dates: # calculate for every date in dates
body_pos = positions[b](t) # calculate position, using this planet of body
new_table[b].append( body_pos ) # generate a new table
df = pd.DataFrame(data=new_table)
return df
df = generate_table(dates)
df.sample(15)
Out[102]:
In [104]:
df.to_csv('planets.csv', sep=';')
In [ ]: